// var i;
// var $resKeeper = require("./ResKeeper");
// var s = cc._decorator;
// var l = s.ccclass;
// var u = s.property;
// var d = s.inspector;
// var p = (function (e) {
//     function t() {
//         var t = (null !== e && e.apply(this, arguments)) || this;
//         t.xuedi = null;
//         t.mosteids = {
//             1: {
//                 w: 123,
//                 h: 123
//             }
//         };
//         t.pool = null;
//         t.saveNodes = [];
//         t.tw = null;
//         t.offtime = 0;
//         return t;
//     }
//     __extends(t, e);
//     t.prototype.onEnable = function () {
//         var e = this;
//         this.node.children.forEach(function (t) {
//             t.scale = 0;
//             t.opacity = 0;
//             e.huishouNode(t);
//         });
//         this.sendXueDi();
//     };
//     t.prototype.getLiuXueNode = function () {
//         var e = this.saveNodes.shift();
//         if (!e) {
//             e = cc.instantiate(this.xuedi);
//             this.node.addChild(e);
//         }
//         return e;
//     };
//     t.prototype.huishouNode = function (e) {
//         this.saveNodes.push(e);
//     };
//     t.prototype.generateRandomPoint = function (e, t) {
//         var o = 2 * Math.random() * Math.PI;
//         var n = Math.random() * t;
//         return e.add(new cc.Vec2(Math.cos(o) * n, Math.sin(o) * n));
//     };
//     t.prototype.sendXueDi = function () {
//         var e = this;
//         var t = this.getRandomPosition(this.node.getBoundingBox());
//         var o = this.getLiuXueNode();
//         o.x = t.x;
//         o.y = t.y;
//         o.scale = 0;
//         o.opacity = 0;
//         this.tw = cc
//             .tween(o)
//             .to(0.1, {
//                 scale: 1.2,
//                 opacity: 255
//             })
//             .to(0.5, {
//                 scale: 0,
//                 opacity: 0,
//                 y: o.y - 150
//             })
//             .call(function () {
//                 e.huishouNode(o);
//             })
//             .start();
//     };
//     t.prototype.getRandomPosition = function (e) {
//         var t = e.x + Math.random() * e.width;
//         var o = e.y + Math.random() * e.height + 50;
//         return new cc.Vec2(t, o);
//     };
//     t.prototype.update = function (e) {
//         this.offtime += e;
//         if (this.offtime > 0.2) {
//             this.sendXueDi();
//             this.offtime = 0;
//         }
//     };
//     t.prototype.onDisable = function () {
//         var e = this;
//         if (this.tw) {
//             this.tw.stop();
//             this.node.children.forEach(function (t) {
//                 t.scale = 0;
//                 t.opacity = 0;
//                 e.huishouNode(t);
//             });
//         }
//     };
//     __decorate([u(cc.Node)], t.prototype, "xuedi", void 0);
//     return __decorate([l], t);
// })($resKeeper.default);
// exports.default = p;


// const { ccclass, property, inspector } = cc._decorator;

// /** 
//  * 建议名称: XueDiManager 
//  * 血滴管理类，用于生成和回收血滴节点。
//  */
// @ccclass
// class UI_LiuXue extends cc.Component {

//     /** 
//      * 建议名称: xueDiNodePrefab 
//      * 血滴节点的预制资源。
//      */
//     @property(cc.Node)
//     xuedi: cc.Node | null = null;

//     /** 
//      * 建议名称: mosterIds 
//      * 怪物ID字典，记录怪物的宽高信息。
//      */
//     mosteids: { [key: number]: { w: number, h: number } } = {
//         1: {
//             w: 123,
//             h: 123
//         }
//     };

//     /** 
//      * 建议名称: objectPool 
//      * 节点对象池。
//      */
//     private pool: any = null;

//     /** 
//      * 建议名称: savedNodes 
//      * 存储被回收的血滴节点。
//      */
//     private saveNodes: cc.Node[] = [];

//     /** 
//      * 建议名称: currentTween 
//      * 当前血滴节点的动画。
//      */
//     private tw: cc.Tween<cc.Node> | null = null;

//     /** 
//      * 建议名称: offTime 
//      * 离在线时间累计。
//      */
//     private offtime: number = 0;

//     /**
//      * 当节点启用时调用此方法。初始化节点并回收所有节点。
//      * 建议名称: handleOnEnable
//      */
//     onEnable(): void {
//         this.node.children.forEach((child: cc.Node) => {
//             child.scale = 0;
//             child.opacity = 0;
//             this.huishouNode(child);
//         });
//         this.sendXueDi();
//     }

//     /**
//      * 获取一个血滴节点，如果没有则实例化一个新的。
//      * @return {cc.Node} 血滴节点
//      * 建议名称: fetchLiuXueNode
//      */
//     getLiuXueNode(): cc.Node {
//         let node = this.saveNodes.shift();
//         if (!node) {
//             node = cc.instantiate(this.xuedi!);
//             this.node.addChild(node);
//         }
//         return node;
//     }

//     /**
//      * 回收一个血滴节点，放入保存数组中。
//      * @param {cc.Node} node 需要回收的血滴节点
//      * 建议名称: recycleNode
//      */
//     huishouNode(node: cc.Node): void {
//         this.saveNodes.push(node);
//     }

//     /**
//      * 生成一个随机点位置。
//      * @param {cc.Vec2} center 中心点
//      * @param {number} radius 半径
//      * @return {cc.Vec2} 随机点位置
//      * 建议名称: createRandomPoint
//      */
//     generateRandomPoint(center: cc.Vec2, radius: number): cc.Vec2 {
//         const angle = 2 * Math.random() * Math.PI;
//         const distance = Math.random() * radius;
//         return center.add(new cc.Vec2(Math.cos(angle) * distance, Math.sin(angle) * distance));
//     }

//     /**
//      * 发送新的血滴节点到随机位置，并播放动画。
//      * 建议名称: dispatchXueDi
//      */
//     sendXueDi(): void {
//         const position = this.getRandomPosition(this.node.getBoundingBox());
//         const liuXueNode = this.getLiuXueNode();
//         liuXueNode.setPosition(position);
//         liuXueNode.scale = 0;
//         liuXueNode.opacity = 0;

//         this.tw = cc.tween(liuXueNode)
//             .to(0.1, { scale:1.2, opacity: 255 })
//             .to(0.5, { scale: 0, opacity: 0, y: liuXueNode.position.y - 150 })
//             .call(() => {
//                 this.huishouNode(liuXueNode);
//             })
//             .start();
//     }

//     /**
//      * 获取随机位置。
//      * @param {cc.Rect} boundingBox 边界框
//      * @return {cc.Vec2} 随机位置
//      * 建议名称: obtainRandomPosition
//      */
//     getRandomPosition(boundingBox: cc.Rect): cc.Vec2 {
//         const x = boundingBox.x + Math.random() * boundingBox.width;
//         const y = boundingBox.y + Math.random() * boundingBox.height + 50;
//         return new cc.Vec2(x, y);
//     }

//     /**
//      * 每帧调用此方法，更新节点的状态。
//      * @param {number} deltaTime 每帧时间间隔
//      * 建议名称: handleUpdate
//      */
//     update(deltaTime: number): void {
//         this.offtime += deltaTime;
//         if (this.offtime > 0.2) {
//             this.sendXueDi();
//             this.offtime = 0;
//         }
//     }

//     /**
//      * 当节点禁用时调用此方法。停止动画并回收所有节点。
//      * 建议名称: handleOnDisable
//      */
//     onDisable(): void {
//         if (this.tw) {
//             this.tw.stop();
//             this.node.children.forEach((child: cc.Node) => {
//                 child.scale = 0;
//                 child.opacity = 0;
//                 this.huishouNode(child);
//             });
//         }
//     }
// }

// export default UI_LiuXue;

const { ccclass, property } = cc._decorator;

/** 
 * 建议名称: XueDiManager 
 * 血滴管理类，用于生成和回收血滴节点。
 */
@ccclass
class ViewLiuXue extends cc.Component {

    /** 
     * 建议名称: xueDiNodePrefab 
     * 血滴节点的预制资源。
     */
    @property(cc.Node)
    xuedi: cc.Node | null = null;

    /** 
     * 建议名称: mosterIds 
     * 怪物ID字典，记录怪物的宽高信息。
     */
    mosteids: { [key: number]: { w: number, h: number } } = {
        1: {
            w: 123,
            h: 123
        }
    };

    /** 
     * 建议名称: objectPool 
     * 节点对象池。
     */
    private nodePool: any = null;

    /** 
     * 建议名称: savedNodes 
     * 存储被回收的血滴节点。
     */
    private cachedNodes: cc.Node[] = [];

    /** 
     * 建议名称: currentTween 
     * 当前血滴节点的动画。
     */
    private currentTween: cc.Tween<cc.Node> | null = null;

    /** 
     * 建议名称: offTime 
     * 离在线时间累计。
     */
    private accumulatedTime: number = 0;

    /**
     * 当节点启用时调用此方法。初始化节点并回收所有节点。
     * 建议名称: handleOnEnable
     */
    onEnable(): void {
        this.node.children.forEach((nodeChild: cc.Node) => {
            nodeChild.scale = 0;
            nodeChild.opacity = 0;
            this.recycleNode(nodeChild);
        });
        this.dispatchXueDi();
    }

    /**
     * 获取一个血滴节点，如果没有则实例化一个新的。
     * @return {cc.Node} 血滴节点
     * 建议名称: fetchLiuXueNode
     */
    getLiuXueNode(): cc.Node {
        let liuXueNode = this.cachedNodes.shift();
        if (!liuXueNode) {
            liuXueNode = cc.instantiate(this.xuedi!);
            this.node.addChild(liuXueNode);
        }
        return liuXueNode;
    }

    /**
     * 回收一个血滴节点，放入保存数组中。
     * @param {cc.Node} bloodDropNode 需要回收的血滴节点
     * 建议名称: recycleNode
     */
    recycleNode(bloodDropNode: cc.Node): void {
        this.cachedNodes.push(bloodDropNode);
    }

    /**
     * 生成一个随机点位置。
     * @param {cc.Vec2} center 中心点
     * @param {number} radius 半径
     * @return {cc.Vec2} 随机点位置
     * 建议名称: createRandomPoint
     */
    createRandomPoint(center: cc.Vec2, radius: number): cc.Vec2 {
        const randomAngle = 2 * Math.random() * Math.PI;
        const randomDistance = Math.random() * radius;
        return center.add(new cc.Vec2(Math.cos(randomAngle) * randomDistance, Math.sin(randomAngle) * randomDistance));
    }

    /**
     * 发送新的血滴节点到随机位置，并播放动画。
     * 建议名称: dispatchXueDi
     */
    dispatchXueDi(): void {
        const randomPosition = this.obtainRandomPosition(this.node.getBoundingBox());
        const liuXueNode = this.getLiuXueNode();
        liuXueNode.setPosition(randomPosition);
        liuXueNode.scale = 0;
        liuXueNode.opacity = 0;

        this.currentTween = cc.tween(liuXueNode)
            .to(0.1, { scale:1.2, opacity: 255 })
            .to(0.5, { scale: 0, opacity: 0, y: liuXueNode.position.y - 150 })
            .call(() => {
                this.recycleNode(liuXueNode);
            })
            .start();
    }

    /**
     * 获取随机位置。
     * @param {cc.Rect} boundingBox 边界框
     * @return {cc.Vec2} 随机位置
     * 建议名称: obtainRandomPosition
     */
    obtainRandomPosition(boundingBox: cc.Rect): cc.Vec2 {
        const randomX = boundingBox.x + Math.random() * boundingBox.width;
        const randomY = boundingBox.y + Math.random() * boundingBox.height + 50;
        return new cc.Vec2(randomX, randomY);
    }

    /**
     * 每帧调用此方法，更新节点的状态。
     * @param {number} deltaTime 每帧时间间隔
     * 建议名称: handleUpdate
     */
    update(deltaTime: number): void {
        this.accumulatedTime += deltaTime;
        if (this.accumulatedTime > 0.2) {
            this.dispatchXueDi();
            this.accumulatedTime = 0;
        }
    }

    /**
     * 当节点禁用时调用此方法。停止动画并回收所有节点。
     * 建议名称: handleOnDisable
     */
    onDisable(): void {
        if (this.currentTween) {
            this.currentTween.stop();
            this.node.children.forEach((nodeChild: cc.Node) => {
                nodeChild.scale = 0;
                nodeChild.opacity = 0;
                this.recycleNode(nodeChild);
            });
        }
    }
}

export default ViewLiuXue;
